/**
 * HTTP客户端工具类
 * 基于 axios 提供统一的网络请求封装
 */

import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios'
import { ApiResponse, ApiError, API_ENDPOINTS } from '@/lib/types/api'

export class ApiClient {
  private axiosInstance: AxiosInstance

  constructor(baseURL: string = API_ENDPOINTS.BASE_URL) {
    this.axiosInstance = axios.create({
      baseURL,
      timeout: 10000, // 10秒超时
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
      withCredentials: false, // 明确设置不发送cookies
    })

    // 设置请求拦截器
    this.setupRequestInterceptor()
    // 设置响应拦截器
    this.setupResponseInterceptor()
  }

  /**
   * 设置请求拦截器
   */
  private setupRequestInterceptor(): void {
    this.axiosInstance.interceptors.request.use(
      (config) => {
        // 可以在这里添加认证token、请求日志等
        console.log(`🚀 API请求: ${config.method?.toUpperCase()} ${config.url}`)
        return config
      },
      (error) => {
        console.error('请求拦截器错误:', error)
        return Promise.reject(error)
      }
    )
  }

  /**
   * 设置响应拦截器
   */
  private setupResponseInterceptor(): void {
    this.axiosInstance.interceptors.response.use(
      (response: AxiosResponse<ApiResponse>) => {
        console.log(`✅ API响应: ${response.status} ${response.config.url}`)

        // 在响应拦截器中检查业务逻辑
        const data = response.data

        if (data && typeof data === 'object') {
          // 检查业务状态码是否为401未授权
          if (data.code === 401) {
            console.warn('⚠️ 业务状态码401未授权，执行登出流程')
            
            if (typeof window !== 'undefined') {
              // 1. 清除所有本地存储的认证信息
              localStorage.removeItem('token')
              localStorage.removeItem('user')
              localStorage.removeItem('auth-state')
              
              // 2. 清除HTTP客户端的Authorization header
              this.clearAuthToken()
              
              // 3. 设置一个标志，防止重复跳转
              const isRedirecting = sessionStorage.getItem('auth-redirecting')
              if (!isRedirecting) {
                sessionStorage.setItem('auth-redirecting', 'true')
                
                // 4. 延迟跳转，确保清理完成
                setTimeout(() => {
                  sessionStorage.removeItem('auth-redirecting')
                  window.location.href = '/ta/login'
                }, 100)
              }
            }
            
            throw new Error(data.msg || '未授权，请先登录')
          }

          // 检查业务状态码 - 主要根据 success 字段判断
          if (data.success === false) {
            throw new Error(data.msg || '请求失败')
          }

          // 兼容没有 success 字段的情况，检查 code
          // 但如果既没有success也没有code字段，说明是直接返回数据对象（如用户信息），应该视为成功
          if (data.success === undefined && data.code !== undefined && data.code !== 200) {
            throw new Error(data.msg || '业务逻辑错误')
          }
        }

        return response
      },
      (error: AxiosError) => {
        const apiError = this.handleError(error)
        console.error('响应拦截器错误:', apiError)
        return Promise.reject(apiError)
      }
    )
  }

  /**
   * 处理 axios 错误
   */
  private handleError(error: AxiosError): ApiError {
    const url = error.config?.url || 'unknown'
    console.error(`API请求失败 [${url}]:`, error)

    // 请求超时
    if (error.code === 'ECONNABORTED') {
      return {
        code: 408,
        message: '请求超时，请检查网络连接',
        details: error
      }
    }

    // 网络错误
    if (error.code === 'ERR_NETWORK') {
      return {
        code: 0,
        message: '网络连接异常，请检查网络设置',
        details: error
      }
    }

    // HTTP错误响应
    if (error.response) {
      const status = error.response.status
      const data = error.response.data as any

      // 处理401未授权错误 - 跳转到登录页面
      // if (status === 401) {
      //   console.warn('401未授权，跳转到登录页面')
      //   // 清除本地存储的token
      //   if (typeof window !== 'undefined') {
      //     localStorage.removeItem('token')
      //     localStorage.removeItem('user')
      //     // 跳转到登录页面，并保存当前页面路径用于登录后返回
      //     const currentPath = window.location.pathname + window.location.search
      //     const loginPath = `/ta/login?redirect=${encodeURIComponent(currentPath)}`
      //     window.location.href = loginPath
      //   }
      // }

      return {
        code: status,
        message: data?.msg || data?.message || `HTTP ${status}错误`,
        details: error
      }
    }

    // 请求配置错误
    if (error.request) {
      return {
        code: 0,
        message: '网络请求失败，请检查服务器连接',
        details: error
      }
    }

    // 其他错误
    return {
      code: 500,
      message: error.message || '未知网络错误',
      details: error
    }
  }

  /**
   * 处理响应数据
   */
  private handleResponse<T>(response: AxiosResponse<ApiResponse<T>>): ApiResponse<T> {
    const data = response.data
    
    // 验证响应格式
    if (typeof data !== 'object' || data === null) {
      throw new Error('服务器响应格式错误')
    }

    // 注意：业务逻辑检查已经在响应拦截器中处理
    return data
  }

  /**
   * 通用请求方法
   */
  private async request<T>(
    endpoint: string, 
    config: AxiosRequestConfig = {}
  ): Promise<ApiResponse<T>> {
    try {
      const response = await this.axiosInstance.request<ApiResponse<T>>({
        url: endpoint,
        ...config,
      })
      
      return this.handleResponse<T>(response)
    } catch (error) {
      throw error // 错误已在拦截器中处理
    }
  }

  /**
   * GET 请求
   */
  async get<T>(
    endpoint: string, 
    params?: Record<string, any>,
    config?: Omit<AxiosRequestConfig, 'method' | 'params' | 'data'>
  ): Promise<ApiResponse<T>> {
    return this.request<T>(endpoint, {
      ...config,
      method: 'GET',
      params,
    })
  }

  /**
   * POST 请求
   */
  async post<T>(
    endpoint: string, 
    data?: any,
    config?: Omit<AxiosRequestConfig, 'method' | 'data'>
  ): Promise<ApiResponse<T>> {
    return this.request<T>(endpoint, {
      ...config,
      method: 'POST',
      data,
    })
  }

  /**
   * PUT 请求
   */
  async put<T>(
    endpoint: string, 
    data?: any,
    config?: Omit<AxiosRequestConfig, 'method' | 'data'>
  ): Promise<ApiResponse<T>> {
    return this.request<T>(endpoint, {
      ...config,
      method: 'PUT',
      data,
    })
  }

  /**
   * DELETE 请求
   */
  async delete<T>(
    endpoint: string, 
    params?: Record<string, any>,
    config?: Omit<AxiosRequestConfig, 'method' | 'params' | 'data'>
  ): Promise<ApiResponse<T>> {
    return this.request<T>(endpoint, {
      ...config,
      method: 'DELETE',
      params,
    })
  }

  /**
   * 设置默认请求头
   */
  setDefaultHeaders(headers: Record<string, string>): void {
    Object.assign(this.axiosInstance.defaults.headers.common, headers)
  }

  /**
   * 设置认证token
   */
  setAuthToken(token: string): void {
    this.axiosInstance.defaults.headers.common['Authorization'] = `Bearer ${token}`
    console.log('HTTP客户端已设置Authorization头:', `Bearer ${token}`)
  }

  /**
   * 清除认证token
   */
  clearAuthToken(): void {
    delete this.axiosInstance.defaults.headers.common['Authorization']
  }

  /**
   * 获取 axios 实例（用于高级配置）
   */
  getAxiosInstance(): AxiosInstance {
    return this.axiosInstance
  }

  /**
   * 设置超时时间
   */
  setTimeout(timeout: number): void {
    this.axiosInstance.defaults.timeout = timeout
  }
}

// 创建默认客户端实例
export const apiClient = new ApiClient()

// 导出便捷方法
export const { get, post, put, delete: del } = apiClient